// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.inventory.monthly.real;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.InventoryMonthlyReal;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(InventoryMonthlyReal.class)
@Setter
@Getter
public class InventoryMonthlyRealSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "InventoryMonthlyReal".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("itemId", "p");
    map.put("binId", "wb");
    map.put("stockId", "w");
    map.put("periodId", "ba");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 批号(模糊搜索)
   */
  private String batchNo;

  /**
   * 批号 比较(eq)
   */
  private String batchNoEq;
  /**
   * 批号 比较(neq)
   */
  private String batchNoNeq;
  /**
   * 批号 比较(gt)
   */
  private String batchNoGt;
  /**
   * 批号 比较(gte)
   */
  private String batchNoGte;
  /**
   * 批号 比较(lt)
   */
  private String batchNoLt;
  /**
   * 批号 比较(lte)
   */
  private String batchNoLte;
  /**
   * 批号 比较(contains)
   */
  private String batchNoContains;
  /**
   * 批号 比较(notcontains)
   */
  private String batchNoNotcontains;
  /**
   * 批号 比较(startswith)
   */
  private String batchNoStartswith;
  /**
   * 批号 比较(endswith)
   */
  private String batchNoEndswith;
  /**
   * 批号 比较(isnull)
   */
  private Boolean batchNoIsnull;
  /**
   * 批号 比较(isnotnull)
   */
  private Boolean batchNoIsnotnull;

  /**
   * 批号(精确搜索)
   */
  private List<String> batchNoInList;

  /**
   * 物料内码
   */
  private Long itemId;

  /**
   * 物料内码 比较(eq)
   */
  private Long itemIdEq;
  /**
   * 物料内码 比较(neq)
   */
  private Long itemIdNeq;
  /**
   * 物料内码 比较(gt)
   */
  private Long itemIdGt;
  /**
   * 物料内码 比较(gte)
   */
  private Long itemIdGte;
  /**
   * 物料内码 比较(lt)
   */
  private Long itemIdLt;
  /**
   * 物料内码 比较(lte)
   */
  private Long itemIdLte;
  /**
   * 物料内码 比较(contains)
   */
  private Long itemIdContains;
  /**
   * 物料内码 比较(notcontains)
   */
  private Long itemIdNotcontains;
  /**
   * 物料内码 比较(startswith)
   */
  private Long itemIdStartswith;
  /**
   * 物料内码 比较(endswith)
   */
  private Long itemIdEndswith;
  /**
   * 物料内码 比较(isnull)
   */
  private Boolean itemIdIsnull;
  /**
   * 物料内码 比较(isnotnull)
   */
  private Boolean itemIdIsnotnull;
  /**
   * 物料内码的品名 比较(eq)
   */
  private String itemIdNameEq;
  /**
   * 物料内码的品名 比较(neq)
   */
  private String itemIdNameNeq;
  /**
   * 物料内码的品名 比较(gt)
   */
  private String itemIdNameGt;
  /**
   * 物料内码的品名 比较(gte)
   */
  private String itemIdNameGte;
  /**
   * 物料内码的品名 比较(lt)
   */
  private String itemIdNameLt;
  /**
   * 物料内码的品名 比较(lte)
   */
  private String itemIdNameLte;
  /**
   * 物料内码的品名 比较(contains)
   */
  private String itemIdNameContains;
  /**
   * 物料内码的品名 比较(notcontains)
   */
  private String itemIdNameNotcontains;
  /**
   * 物料内码的品名 比较(startswith)
   */
  private String itemIdNameStartswith;
  /**
   * 物料内码的品名 比较(endswith)
   */
  private String itemIdNameEndswith;
  /**
   * 物料内码的品名 比较(isnull)
   */
  private Boolean itemIdNameIsnull;
  /**
   * 物料内码的品名 比较(isnotnull)
   */
  private Boolean itemIdNameIsnotnull;

  /**
   * 物料内码(范围搜索)
   */
  private List<Long> itemIdInList;

  /**
   * 项目内码
   */
  private Long projectId;

  /**
   * 最小项目内码
   */
  private Long projectIdMin;

  /**
   * 最大项目内码
   */
  private Long projectIdMax;

  /**
   * 项目内码 比较(eq)
   */
  private Long projectIdEq;
  /**
   * 项目内码 比较(neq)
   */
  private Long projectIdNeq;
  /**
   * 项目内码 比较(gt)
   */
  private Long projectIdGt;
  /**
   * 项目内码 比较(gte)
   */
  private Long projectIdGte;
  /**
   * 项目内码 比较(lt)
   */
  private Long projectIdLt;
  /**
   * 项目内码 比较(lte)
   */
  private Long projectIdLte;
  /**
   * 项目内码 比较(contains)
   */
  private Long projectIdContains;
  /**
   * 项目内码 比较(notcontains)
   */
  private Long projectIdNotcontains;
  /**
   * 项目内码 比较(startswith)
   */
  private Long projectIdStartswith;
  /**
   * 项目内码 比较(endswith)
   */
  private Long projectIdEndswith;
  /**
   * 项目内码 比较(isnull)
   */
  private Boolean projectIdIsnull;
  /**
   * 项目内码 比较(isnotnull)
   */
  private Boolean projectIdIsnotnull;

  /**
   * 库位内码
   */
  private Long binId;

  /**
   * 库位内码 比较(eq)
   */
  private Long binIdEq;
  /**
   * 库位内码 比较(neq)
   */
  private Long binIdNeq;
  /**
   * 库位内码 比较(gt)
   */
  private Long binIdGt;
  /**
   * 库位内码 比较(gte)
   */
  private Long binIdGte;
  /**
   * 库位内码 比较(lt)
   */
  private Long binIdLt;
  /**
   * 库位内码 比较(lte)
   */
  private Long binIdLte;
  /**
   * 库位内码 比较(contains)
   */
  private Long binIdContains;
  /**
   * 库位内码 比较(notcontains)
   */
  private Long binIdNotcontains;
  /**
   * 库位内码 比较(startswith)
   */
  private Long binIdStartswith;
  /**
   * 库位内码 比较(endswith)
   */
  private Long binIdEndswith;
  /**
   * 库位内码 比较(isnull)
   */
  private Boolean binIdIsnull;
  /**
   * 库位内码 比较(isnotnull)
   */
  private Boolean binIdIsnotnull;
  /**
   * 库位内码的仓位 比较(eq)
   */
  private String binIdStorageBinEq;
  /**
   * 库位内码的仓位 比较(neq)
   */
  private String binIdStorageBinNeq;
  /**
   * 库位内码的仓位 比较(gt)
   */
  private String binIdStorageBinGt;
  /**
   * 库位内码的仓位 比较(gte)
   */
  private String binIdStorageBinGte;
  /**
   * 库位内码的仓位 比较(lt)
   */
  private String binIdStorageBinLt;
  /**
   * 库位内码的仓位 比较(lte)
   */
  private String binIdStorageBinLte;
  /**
   * 库位内码的仓位 比较(contains)
   */
  private String binIdStorageBinContains;
  /**
   * 库位内码的仓位 比较(notcontains)
   */
  private String binIdStorageBinNotcontains;
  /**
   * 库位内码的仓位 比较(startswith)
   */
  private String binIdStorageBinStartswith;
  /**
   * 库位内码的仓位 比较(endswith)
   */
  private String binIdStorageBinEndswith;
  /**
   * 库位内码的仓位 比较(isnull)
   */
  private Boolean binIdStorageBinIsnull;
  /**
   * 库位内码的仓位 比较(isnotnull)
   */
  private Boolean binIdStorageBinIsnotnull;

  /**
   * 库位内码(范围搜索)
   */
  private List<Long> binIdInList;

  /**
   * 仓库内码
   */
  private Long stockId;

  /**
   * 仓库内码 比较(eq)
   */
  private Long stockIdEq;
  /**
   * 仓库内码 比较(neq)
   */
  private Long stockIdNeq;
  /**
   * 仓库内码 比较(gt)
   */
  private Long stockIdGt;
  /**
   * 仓库内码 比较(gte)
   */
  private Long stockIdGte;
  /**
   * 仓库内码 比较(lt)
   */
  private Long stockIdLt;
  /**
   * 仓库内码 比较(lte)
   */
  private Long stockIdLte;
  /**
   * 仓库内码 比较(contains)
   */
  private Long stockIdContains;
  /**
   * 仓库内码 比较(notcontains)
   */
  private Long stockIdNotcontains;
  /**
   * 仓库内码 比较(startswith)
   */
  private Long stockIdStartswith;
  /**
   * 仓库内码 比较(endswith)
   */
  private Long stockIdEndswith;
  /**
   * 仓库内码 比较(isnull)
   */
  private Boolean stockIdIsnull;
  /**
   * 仓库内码 比较(isnotnull)
   */
  private Boolean stockIdIsnotnull;
  /**
   * 仓库内码的仓库名称 比较(eq)
   */
  private String stockIdNameEq;
  /**
   * 仓库内码的仓库名称 比较(neq)
   */
  private String stockIdNameNeq;
  /**
   * 仓库内码的仓库名称 比较(gt)
   */
  private String stockIdNameGt;
  /**
   * 仓库内码的仓库名称 比较(gte)
   */
  private String stockIdNameGte;
  /**
   * 仓库内码的仓库名称 比较(lt)
   */
  private String stockIdNameLt;
  /**
   * 仓库内码的仓库名称 比较(lte)
   */
  private String stockIdNameLte;
  /**
   * 仓库内码的仓库名称 比较(contains)
   */
  private String stockIdNameContains;
  /**
   * 仓库内码的仓库名称 比较(notcontains)
   */
  private String stockIdNameNotcontains;
  /**
   * 仓库内码的仓库名称 比较(startswith)
   */
  private String stockIdNameStartswith;
  /**
   * 仓库内码的仓库名称 比较(endswith)
   */
  private String stockIdNameEndswith;
  /**
   * 仓库内码的仓库名称 比较(isnull)
   */
  private Boolean stockIdNameIsnull;
  /**
   * 仓库内码的仓库名称 比较(isnotnull)
   */
  private Boolean stockIdNameIsnotnull;

  /**
   * 仓库内码(范围搜索)
   */
  private List<Long> stockIdInList;

  /**
   * 会计月内码
   */
  private Long periodId;

  /**
   * 会计月内码 比较(eq)
   */
  private Long periodIdEq;
  /**
   * 会计月内码 比较(neq)
   */
  private Long periodIdNeq;
  /**
   * 会计月内码 比较(gt)
   */
  private Long periodIdGt;
  /**
   * 会计月内码 比较(gte)
   */
  private Long periodIdGte;
  /**
   * 会计月内码 比较(lt)
   */
  private Long periodIdLt;
  /**
   * 会计月内码 比较(lte)
   */
  private Long periodIdLte;
  /**
   * 会计月内码 比较(contains)
   */
  private Long periodIdContains;
  /**
   * 会计月内码 比较(notcontains)
   */
  private Long periodIdNotcontains;
  /**
   * 会计月内码 比较(startswith)
   */
  private Long periodIdStartswith;
  /**
   * 会计月内码 比较(endswith)
   */
  private Long periodIdEndswith;
  /**
   * 会计月内码 比较(isnull)
   */
  private Boolean periodIdIsnull;
  /**
   * 会计月内码 比较(isnotnull)
   */
  private Boolean periodIdIsnotnull;
  /**
   * 会计月内码的会计月份 比较(eq)
   */
  private String periodIdAccperiodMonthEq;
  /**
   * 会计月内码的会计月份 比较(neq)
   */
  private String periodIdAccperiodMonthNeq;
  /**
   * 会计月内码的会计月份 比较(gt)
   */
  private String periodIdAccperiodMonthGt;
  /**
   * 会计月内码的会计月份 比较(gte)
   */
  private String periodIdAccperiodMonthGte;
  /**
   * 会计月内码的会计月份 比较(lt)
   */
  private String periodIdAccperiodMonthLt;
  /**
   * 会计月内码的会计月份 比较(lte)
   */
  private String periodIdAccperiodMonthLte;
  /**
   * 会计月内码的会计月份 比较(contains)
   */
  private String periodIdAccperiodMonthContains;
  /**
   * 会计月内码的会计月份 比较(notcontains)
   */
  private String periodIdAccperiodMonthNotcontains;
  /**
   * 会计月内码的会计月份 比较(startswith)
   */
  private String periodIdAccperiodMonthStartswith;
  /**
   * 会计月内码的会计月份 比较(endswith)
   */
  private String periodIdAccperiodMonthEndswith;
  /**
   * 会计月内码的会计月份 比较(isnull)
   */
  private Boolean periodIdAccperiodMonthIsnull;
  /**
   * 会计月内码的会计月份 比较(isnotnull)
   */
  private Boolean periodIdAccperiodMonthIsnotnull;

  /**
   * 会计月内码(范围搜索)
   */
  private List<Long> periodIdInList;

  /**
   * 在途数量
   */
  private java.math.BigDecimal wayQty;

  /**
   * 最小在途数量
   */
  private java.math.BigDecimal wayQtyMin;

  /**
   * 最大在途数量
   */
  private java.math.BigDecimal wayQtyMax;

  /**
   * 在途数量 比较(eq)
   */
  private java.math.BigDecimal wayQtyEq;
  /**
   * 在途数量 比较(neq)
   */
  private java.math.BigDecimal wayQtyNeq;
  /**
   * 在途数量 比较(gt)
   */
  private java.math.BigDecimal wayQtyGt;
  /**
   * 在途数量 比较(gte)
   */
  private java.math.BigDecimal wayQtyGte;
  /**
   * 在途数量 比较(lt)
   */
  private java.math.BigDecimal wayQtyLt;
  /**
   * 在途数量 比较(lte)
   */
  private java.math.BigDecimal wayQtyLte;
  /**
   * 在途数量 比较(contains)
   */
  private java.math.BigDecimal wayQtyContains;
  /**
   * 在途数量 比较(notcontains)
   */
  private java.math.BigDecimal wayQtyNotcontains;
  /**
   * 在途数量 比较(startswith)
   */
  private java.math.BigDecimal wayQtyStartswith;
  /**
   * 在途数量 比较(endswith)
   */
  private java.math.BigDecimal wayQtyEndswith;
  /**
   * 在途数量 比较(isnull)
   */
  private Boolean wayQtyIsnull;
  /**
   * 在途数量 比较(isnotnull)
   */
  private Boolean wayQtyIsnotnull;

  /**
   * 残次数量
   */
  private java.math.BigDecimal defectQty;

  /**
   * 最小残次数量
   */
  private java.math.BigDecimal defectQtyMin;

  /**
   * 最大残次数量
   */
  private java.math.BigDecimal defectQtyMax;

  /**
   * 残次数量 比较(eq)
   */
  private java.math.BigDecimal defectQtyEq;
  /**
   * 残次数量 比较(neq)
   */
  private java.math.BigDecimal defectQtyNeq;
  /**
   * 残次数量 比较(gt)
   */
  private java.math.BigDecimal defectQtyGt;
  /**
   * 残次数量 比较(gte)
   */
  private java.math.BigDecimal defectQtyGte;
  /**
   * 残次数量 比较(lt)
   */
  private java.math.BigDecimal defectQtyLt;
  /**
   * 残次数量 比较(lte)
   */
  private java.math.BigDecimal defectQtyLte;
  /**
   * 残次数量 比较(contains)
   */
  private java.math.BigDecimal defectQtyContains;
  /**
   * 残次数量 比较(notcontains)
   */
  private java.math.BigDecimal defectQtyNotcontains;
  /**
   * 残次数量 比较(startswith)
   */
  private java.math.BigDecimal defectQtyStartswith;
  /**
   * 残次数量 比较(endswith)
   */
  private java.math.BigDecimal defectQtyEndswith;
  /**
   * 残次数量 比较(isnull)
   */
  private Boolean defectQtyIsnull;
  /**
   * 残次数量 比较(isnotnull)
   */
  private Boolean defectQtyIsnotnull;

  /**
   * 陈列数量
   */
  private java.math.BigDecimal displayQty;

  /**
   * 最小陈列数量
   */
  private java.math.BigDecimal displayQtyMin;

  /**
   * 最大陈列数量
   */
  private java.math.BigDecimal displayQtyMax;

  /**
   * 陈列数量 比较(eq)
   */
  private java.math.BigDecimal displayQtyEq;
  /**
   * 陈列数量 比较(neq)
   */
  private java.math.BigDecimal displayQtyNeq;
  /**
   * 陈列数量 比较(gt)
   */
  private java.math.BigDecimal displayQtyGt;
  /**
   * 陈列数量 比较(gte)
   */
  private java.math.BigDecimal displayQtyGte;
  /**
   * 陈列数量 比较(lt)
   */
  private java.math.BigDecimal displayQtyLt;
  /**
   * 陈列数量 比较(lte)
   */
  private java.math.BigDecimal displayQtyLte;
  /**
   * 陈列数量 比较(contains)
   */
  private java.math.BigDecimal displayQtyContains;
  /**
   * 陈列数量 比较(notcontains)
   */
  private java.math.BigDecimal displayQtyNotcontains;
  /**
   * 陈列数量 比较(startswith)
   */
  private java.math.BigDecimal displayQtyStartswith;
  /**
   * 陈列数量 比较(endswith)
   */
  private java.math.BigDecimal displayQtyEndswith;
  /**
   * 陈列数量 比较(isnull)
   */
  private Boolean displayQtyIsnull;
  /**
   * 陈列数量 比较(isnotnull)
   */
  private Boolean displayQtyIsnotnull;

  /**
   * 锁库数量
   */
  private java.math.BigDecimal lockQty;

  /**
   * 最小锁库数量
   */
  private java.math.BigDecimal lockQtyMin;

  /**
   * 最大锁库数量
   */
  private java.math.BigDecimal lockQtyMax;

  /**
   * 锁库数量 比较(eq)
   */
  private java.math.BigDecimal lockQtyEq;
  /**
   * 锁库数量 比较(neq)
   */
  private java.math.BigDecimal lockQtyNeq;
  /**
   * 锁库数量 比较(gt)
   */
  private java.math.BigDecimal lockQtyGt;
  /**
   * 锁库数量 比较(gte)
   */
  private java.math.BigDecimal lockQtyGte;
  /**
   * 锁库数量 比较(lt)
   */
  private java.math.BigDecimal lockQtyLt;
  /**
   * 锁库数量 比较(lte)
   */
  private java.math.BigDecimal lockQtyLte;
  /**
   * 锁库数量 比较(contains)
   */
  private java.math.BigDecimal lockQtyContains;
  /**
   * 锁库数量 比较(notcontains)
   */
  private java.math.BigDecimal lockQtyNotcontains;
  /**
   * 锁库数量 比较(startswith)
   */
  private java.math.BigDecimal lockQtyStartswith;
  /**
   * 锁库数量 比较(endswith)
   */
  private java.math.BigDecimal lockQtyEndswith;
  /**
   * 锁库数量 比较(isnull)
   */
  private Boolean lockQtyIsnull;
  /**
   * 锁库数量 比较(isnotnull)
   */
  private Boolean lockQtyIsnotnull;

  /**
   * 辅助数量
   */
  private java.math.BigDecimal auxQty;

  /**
   * 最小辅助数量
   */
  private java.math.BigDecimal auxQtyMin;

  /**
   * 最大辅助数量
   */
  private java.math.BigDecimal auxQtyMax;

  /**
   * 辅助数量 比较(eq)
   */
  private java.math.BigDecimal auxQtyEq;
  /**
   * 辅助数量 比较(neq)
   */
  private java.math.BigDecimal auxQtyNeq;
  /**
   * 辅助数量 比较(gt)
   */
  private java.math.BigDecimal auxQtyGt;
  /**
   * 辅助数量 比较(gte)
   */
  private java.math.BigDecimal auxQtyGte;
  /**
   * 辅助数量 比较(lt)
   */
  private java.math.BigDecimal auxQtyLt;
  /**
   * 辅助数量 比较(lte)
   */
  private java.math.BigDecimal auxQtyLte;
  /**
   * 辅助数量 比较(contains)
   */
  private java.math.BigDecimal auxQtyContains;
  /**
   * 辅助数量 比较(notcontains)
   */
  private java.math.BigDecimal auxQtyNotcontains;
  /**
   * 辅助数量 比较(startswith)
   */
  private java.math.BigDecimal auxQtyStartswith;
  /**
   * 辅助数量 比较(endswith)
   */
  private java.math.BigDecimal auxQtyEndswith;
  /**
   * 辅助数量 比较(isnull)
   */
  private Boolean auxQtyIsnull;
  /**
   * 辅助数量 比较(isnotnull)
   */
  private Boolean auxQtyIsnotnull;

  /**
   * 辅助属性内码
   */
  private Long auxId;

  /**
   * 最小辅助属性内码
   */
  private Long auxIdMin;

  /**
   * 最大辅助属性内码
   */
  private Long auxIdMax;

  /**
   * 辅助属性内码 比较(eq)
   */
  private Long auxIdEq;
  /**
   * 辅助属性内码 比较(neq)
   */
  private Long auxIdNeq;
  /**
   * 辅助属性内码 比较(gt)
   */
  private Long auxIdGt;
  /**
   * 辅助属性内码 比较(gte)
   */
  private Long auxIdGte;
  /**
   * 辅助属性内码 比较(lt)
   */
  private Long auxIdLt;
  /**
   * 辅助属性内码 比较(lte)
   */
  private Long auxIdLte;
  /**
   * 辅助属性内码 比较(contains)
   */
  private Long auxIdContains;
  /**
   * 辅助属性内码 比较(notcontains)
   */
  private Long auxIdNotcontains;
  /**
   * 辅助属性内码 比较(startswith)
   */
  private Long auxIdStartswith;
  /**
   * 辅助属性内码 比较(endswith)
   */
  private Long auxIdEndswith;
  /**
   * 辅助属性内码 比较(isnull)
   */
  private Boolean auxIdIsnull;
  /**
   * 辅助属性内码 比较(isnotnull)
   */
  private Boolean auxIdIsnotnull;

  /**
   * 库存金额
   */
  private java.math.BigDecimal stockAmount;

  /**
   * 最小库存金额
   */
  private java.math.BigDecimal stockAmountMin;

  /**
   * 最大库存金额
   */
  private java.math.BigDecimal stockAmountMax;

  /**
   * 库存金额 比较(eq)
   */
  private java.math.BigDecimal stockAmountEq;
  /**
   * 库存金额 比较(neq)
   */
  private java.math.BigDecimal stockAmountNeq;
  /**
   * 库存金额 比较(gt)
   */
  private java.math.BigDecimal stockAmountGt;
  /**
   * 库存金额 比较(gte)
   */
  private java.math.BigDecimal stockAmountGte;
  /**
   * 库存金额 比较(lt)
   */
  private java.math.BigDecimal stockAmountLt;
  /**
   * 库存金额 比较(lte)
   */
  private java.math.BigDecimal stockAmountLte;
  /**
   * 库存金额 比较(contains)
   */
  private java.math.BigDecimal stockAmountContains;
  /**
   * 库存金额 比较(notcontains)
   */
  private java.math.BigDecimal stockAmountNotcontains;
  /**
   * 库存金额 比较(startswith)
   */
  private java.math.BigDecimal stockAmountStartswith;
  /**
   * 库存金额 比较(endswith)
   */
  private java.math.BigDecimal stockAmountEndswith;
  /**
   * 库存金额 比较(isnull)
   */
  private Boolean stockAmountIsnull;
  /**
   * 库存金额 比较(isnotnull)
   */
  private Boolean stockAmountIsnotnull;

  /**
   * 库存数量
   */
  private java.math.BigDecimal stockQty;

  /**
   * 最小库存数量
   */
  private java.math.BigDecimal stockQtyMin;

  /**
   * 最大库存数量
   */
  private java.math.BigDecimal stockQtyMax;

  /**
   * 库存数量 比较(eq)
   */
  private java.math.BigDecimal stockQtyEq;
  /**
   * 库存数量 比较(neq)
   */
  private java.math.BigDecimal stockQtyNeq;
  /**
   * 库存数量 比较(gt)
   */
  private java.math.BigDecimal stockQtyGt;
  /**
   * 库存数量 比较(gte)
   */
  private java.math.BigDecimal stockQtyGte;
  /**
   * 库存数量 比较(lt)
   */
  private java.math.BigDecimal stockQtyLt;
  /**
   * 库存数量 比较(lte)
   */
  private java.math.BigDecimal stockQtyLte;
  /**
   * 库存数量 比较(contains)
   */
  private java.math.BigDecimal stockQtyContains;
  /**
   * 库存数量 比较(notcontains)
   */
  private java.math.BigDecimal stockQtyNotcontains;
  /**
   * 库存数量 比较(startswith)
   */
  private java.math.BigDecimal stockQtyStartswith;
  /**
   * 库存数量 比较(endswith)
   */
  private java.math.BigDecimal stockQtyEndswith;
  /**
   * 库存数量 比较(isnull)
   */
  private Boolean stockQtyIsnull;
  /**
   * 库存数量 比较(isnotnull)
   */
  private Boolean stockQtyIsnotnull;

  /**
   * 出库金额
   */
  private java.math.BigDecimal stockOutAmount;

  /**
   * 最小出库金额
   */
  private java.math.BigDecimal stockOutAmountMin;

  /**
   * 最大出库金额
   */
  private java.math.BigDecimal stockOutAmountMax;

  /**
   * 出库金额 比较(eq)
   */
  private java.math.BigDecimal stockOutAmountEq;
  /**
   * 出库金额 比较(neq)
   */
  private java.math.BigDecimal stockOutAmountNeq;
  /**
   * 出库金额 比较(gt)
   */
  private java.math.BigDecimal stockOutAmountGt;
  /**
   * 出库金额 比较(gte)
   */
  private java.math.BigDecimal stockOutAmountGte;
  /**
   * 出库金额 比较(lt)
   */
  private java.math.BigDecimal stockOutAmountLt;
  /**
   * 出库金额 比较(lte)
   */
  private java.math.BigDecimal stockOutAmountLte;
  /**
   * 出库金额 比较(contains)
   */
  private java.math.BigDecimal stockOutAmountContains;
  /**
   * 出库金额 比较(notcontains)
   */
  private java.math.BigDecimal stockOutAmountNotcontains;
  /**
   * 出库金额 比较(startswith)
   */
  private java.math.BigDecimal stockOutAmountStartswith;
  /**
   * 出库金额 比较(endswith)
   */
  private java.math.BigDecimal stockOutAmountEndswith;
  /**
   * 出库金额 比较(isnull)
   */
  private Boolean stockOutAmountIsnull;
  /**
   * 出库金额 比较(isnotnull)
   */
  private Boolean stockOutAmountIsnotnull;

  /**
   * 出库数量
   */
  private java.math.BigDecimal stockOutQty;

  /**
   * 最小出库数量
   */
  private java.math.BigDecimal stockOutQtyMin;

  /**
   * 最大出库数量
   */
  private java.math.BigDecimal stockOutQtyMax;

  /**
   * 出库数量 比较(eq)
   */
  private java.math.BigDecimal stockOutQtyEq;
  /**
   * 出库数量 比较(neq)
   */
  private java.math.BigDecimal stockOutQtyNeq;
  /**
   * 出库数量 比较(gt)
   */
  private java.math.BigDecimal stockOutQtyGt;
  /**
   * 出库数量 比较(gte)
   */
  private java.math.BigDecimal stockOutQtyGte;
  /**
   * 出库数量 比较(lt)
   */
  private java.math.BigDecimal stockOutQtyLt;
  /**
   * 出库数量 比较(lte)
   */
  private java.math.BigDecimal stockOutQtyLte;
  /**
   * 出库数量 比较(contains)
   */
  private java.math.BigDecimal stockOutQtyContains;
  /**
   * 出库数量 比较(notcontains)
   */
  private java.math.BigDecimal stockOutQtyNotcontains;
  /**
   * 出库数量 比较(startswith)
   */
  private java.math.BigDecimal stockOutQtyStartswith;
  /**
   * 出库数量 比较(endswith)
   */
  private java.math.BigDecimal stockOutQtyEndswith;
  /**
   * 出库数量 比较(isnull)
   */
  private Boolean stockOutQtyIsnull;
  /**
   * 出库数量 比较(isnotnull)
   */
  private Boolean stockOutQtyIsnotnull;

  /**
   * 入库金额
   */
  private java.math.BigDecimal stockInAmount;

  /**
   * 最小入库金额
   */
  private java.math.BigDecimal stockInAmountMin;

  /**
   * 最大入库金额
   */
  private java.math.BigDecimal stockInAmountMax;

  /**
   * 入库金额 比较(eq)
   */
  private java.math.BigDecimal stockInAmountEq;
  /**
   * 入库金额 比较(neq)
   */
  private java.math.BigDecimal stockInAmountNeq;
  /**
   * 入库金额 比较(gt)
   */
  private java.math.BigDecimal stockInAmountGt;
  /**
   * 入库金额 比较(gte)
   */
  private java.math.BigDecimal stockInAmountGte;
  /**
   * 入库金额 比较(lt)
   */
  private java.math.BigDecimal stockInAmountLt;
  /**
   * 入库金额 比较(lte)
   */
  private java.math.BigDecimal stockInAmountLte;
  /**
   * 入库金额 比较(contains)
   */
  private java.math.BigDecimal stockInAmountContains;
  /**
   * 入库金额 比较(notcontains)
   */
  private java.math.BigDecimal stockInAmountNotcontains;
  /**
   * 入库金额 比较(startswith)
   */
  private java.math.BigDecimal stockInAmountStartswith;
  /**
   * 入库金额 比较(endswith)
   */
  private java.math.BigDecimal stockInAmountEndswith;
  /**
   * 入库金额 比较(isnull)
   */
  private Boolean stockInAmountIsnull;
  /**
   * 入库金额 比较(isnotnull)
   */
  private Boolean stockInAmountIsnotnull;

  /**
   * 入库数量
   */
  private java.math.BigDecimal stockInQty;

  /**
   * 最小入库数量
   */
  private java.math.BigDecimal stockInQtyMin;

  /**
   * 最大入库数量
   */
  private java.math.BigDecimal stockInQtyMax;

  /**
   * 入库数量 比较(eq)
   */
  private java.math.BigDecimal stockInQtyEq;
  /**
   * 入库数量 比较(neq)
   */
  private java.math.BigDecimal stockInQtyNeq;
  /**
   * 入库数量 比较(gt)
   */
  private java.math.BigDecimal stockInQtyGt;
  /**
   * 入库数量 比较(gte)
   */
  private java.math.BigDecimal stockInQtyGte;
  /**
   * 入库数量 比较(lt)
   */
  private java.math.BigDecimal stockInQtyLt;
  /**
   * 入库数量 比较(lte)
   */
  private java.math.BigDecimal stockInQtyLte;
  /**
   * 入库数量 比较(contains)
   */
  private java.math.BigDecimal stockInQtyContains;
  /**
   * 入库数量 比较(notcontains)
   */
  private java.math.BigDecimal stockInQtyNotcontains;
  /**
   * 入库数量 比较(startswith)
   */
  private java.math.BigDecimal stockInQtyStartswith;
  /**
   * 入库数量 比较(endswith)
   */
  private java.math.BigDecimal stockInQtyEndswith;
  /**
   * 入库数量 比较(isnull)
   */
  private Boolean stockInQtyIsnull;
  /**
   * 入库数量 比较(isnotnull)
   */
  private Boolean stockInQtyIsnotnull;

  /**
   * 期初金额
   */
  private java.math.BigDecimal beginAmount;

  /**
   * 最小期初金额
   */
  private java.math.BigDecimal beginAmountMin;

  /**
   * 最大期初金额
   */
  private java.math.BigDecimal beginAmountMax;

  /**
   * 期初金额 比较(eq)
   */
  private java.math.BigDecimal beginAmountEq;
  /**
   * 期初金额 比较(neq)
   */
  private java.math.BigDecimal beginAmountNeq;
  /**
   * 期初金额 比较(gt)
   */
  private java.math.BigDecimal beginAmountGt;
  /**
   * 期初金额 比较(gte)
   */
  private java.math.BigDecimal beginAmountGte;
  /**
   * 期初金额 比较(lt)
   */
  private java.math.BigDecimal beginAmountLt;
  /**
   * 期初金额 比较(lte)
   */
  private java.math.BigDecimal beginAmountLte;
  /**
   * 期初金额 比较(contains)
   */
  private java.math.BigDecimal beginAmountContains;
  /**
   * 期初金额 比较(notcontains)
   */
  private java.math.BigDecimal beginAmountNotcontains;
  /**
   * 期初金额 比较(startswith)
   */
  private java.math.BigDecimal beginAmountStartswith;
  /**
   * 期初金额 比较(endswith)
   */
  private java.math.BigDecimal beginAmountEndswith;
  /**
   * 期初金额 比较(isnull)
   */
  private Boolean beginAmountIsnull;
  /**
   * 期初金额 比较(isnotnull)
   */
  private Boolean beginAmountIsnotnull;

  /**
   * 期初数量
   */
  private java.math.BigDecimal beginQty;

  /**
   * 最小期初数量
   */
  private java.math.BigDecimal beginQtyMin;

  /**
   * 最大期初数量
   */
  private java.math.BigDecimal beginQtyMax;

  /**
   * 期初数量 比较(eq)
   */
  private java.math.BigDecimal beginQtyEq;
  /**
   * 期初数量 比较(neq)
   */
  private java.math.BigDecimal beginQtyNeq;
  /**
   * 期初数量 比较(gt)
   */
  private java.math.BigDecimal beginQtyGt;
  /**
   * 期初数量 比较(gte)
   */
  private java.math.BigDecimal beginQtyGte;
  /**
   * 期初数量 比较(lt)
   */
  private java.math.BigDecimal beginQtyLt;
  /**
   * 期初数量 比较(lte)
   */
  private java.math.BigDecimal beginQtyLte;
  /**
   * 期初数量 比较(contains)
   */
  private java.math.BigDecimal beginQtyContains;
  /**
   * 期初数量 比较(notcontains)
   */
  private java.math.BigDecimal beginQtyNotcontains;
  /**
   * 期初数量 比较(startswith)
   */
  private java.math.BigDecimal beginQtyStartswith;
  /**
   * 期初数量 比较(endswith)
   */
  private java.math.BigDecimal beginQtyEndswith;
  /**
   * 期初数量 比较(isnull)
   */
  private Boolean beginQtyIsnull;
  /**
   * 期初数量 比较(isnotnull)
   */
  private Boolean beginQtyIsnotnull;

  /**
   * 最早有效期至
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date expiryDateStart;

  /**
   * 最晚有效期至
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date expiryDateEnd;

  /**
   * 有效期至 比较(eq)
   */
  private Date expiryDateEq;
  /**
   * 有效期至 比较(neq)
   */
  private Date expiryDateNeq;
  /**
   * 有效期至 比较(gt)
   */
  private Date expiryDateGt;
  /**
   * 有效期至 比较(gte)
   */
  private Date expiryDateGte;
  /**
   * 有效期至 比较(lt)
   */
  private Date expiryDateLt;
  /**
   * 有效期至 比较(lte)
   */
  private Date expiryDateLte;
  /**
   * 有效期至 比较(contains)
   */
  private Date expiryDateContains;
  /**
   * 有效期至 比较(notcontains)
   */
  private Date expiryDateNotcontains;
  /**
   * 有效期至 比较(startswith)
   */
  private Date expiryDateStartswith;
  /**
   * 有效期至 比较(endswith)
   */
  private Date expiryDateEndswith;
  /**
   * 有效期至 比较(isnull)
   */
  private Boolean expiryDateIsnull;
  /**
   * 有效期至 比较(isnotnull)
   */
  private Boolean expiryDateIsnotnull;

  /**
   * 最早生产日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date productionDateStart;

  /**
   * 最晚生产日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date productionDateEnd;

  /**
   * 生产日期 比较(eq)
   */
  private Date productionDateEq;
  /**
   * 生产日期 比较(neq)
   */
  private Date productionDateNeq;
  /**
   * 生产日期 比较(gt)
   */
  private Date productionDateGt;
  /**
   * 生产日期 比较(gte)
   */
  private Date productionDateGte;
  /**
   * 生产日期 比较(lt)
   */
  private Date productionDateLt;
  /**
   * 生产日期 比较(lte)
   */
  private Date productionDateLte;
  /**
   * 生产日期 比较(contains)
   */
  private Date productionDateContains;
  /**
   * 生产日期 比较(notcontains)
   */
  private Date productionDateNotcontains;
  /**
   * 生产日期 比较(startswith)
   */
  private Date productionDateStartswith;
  /**
   * 生产日期 比较(endswith)
   */
  private Date productionDateEndswith;
  /**
   * 生产日期 比较(isnull)
   */
  private Boolean productionDateIsnull;
  /**
   * 生产日期 比较(isnotnull)
   */
  private Boolean productionDateIsnotnull;

  /**
   * 保质期(天)
   */
  private Long shelfLife;

  /**
   * 最小保质期(天)
   */
  private Long shelfLifeMin;

  /**
   * 最大保质期(天)
   */
  private Long shelfLifeMax;

  /**
   * 保质期(天) 比较(eq)
   */
  private Long shelfLifeEq;
  /**
   * 保质期(天) 比较(neq)
   */
  private Long shelfLifeNeq;
  /**
   * 保质期(天) 比较(gt)
   */
  private Long shelfLifeGt;
  /**
   * 保质期(天) 比较(gte)
   */
  private Long shelfLifeGte;
  /**
   * 保质期(天) 比较(lt)
   */
  private Long shelfLifeLt;
  /**
   * 保质期(天) 比较(lte)
   */
  private Long shelfLifeLte;
  /**
   * 保质期(天) 比较(contains)
   */
  private Long shelfLifeContains;
  /**
   * 保质期(天) 比较(notcontains)
   */
  private Long shelfLifeNotcontains;
  /**
   * 保质期(天) 比较(startswith)
   */
  private Long shelfLifeStartswith;
  /**
   * 保质期(天) 比较(endswith)
   */
  private Long shelfLifeEndswith;
  /**
   * 保质期(天) 比较(isnull)
   */
  private Boolean shelfLifeIsnull;
  /**
   * 保质期(天) 比较(isnotnull)
   */
  private Boolean shelfLifeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
